import moment from "moment";
import { consts } from "../../../tools/consts";
/**
 * excel 列名转换
 */
/**
 * Convert from numeric position to letter for column names in Excel
 * @param  {int} n Column number
 * @return {string} Column letter(s) name
 */
export function createCellPos(n) {
    let ordA = "A".charCodeAt(0);
    let ordZ = "Z".charCodeAt(0);
    let len = ordZ - ordA + 1;
    let s = "";
    while (n >= 0) {
        s = String.fromCharCode((n % len) + ordA) + s;
        n = Math.floor(n / len) - 1;
    }
    return s;
}
/**
 * 对Data进行补零的函数 UpdateCpasTableDataZero
 * @params  cpasTable:  CPAS基础数据data, cmapsData:请求后返回的data, arrangeIndex: 从第n+1列开始处理(默认从第n+1列开始处理)。
 * @returns newCpasTableData 返回处理之后的值
 *
 */
export function UpdateCpasTableDataZero(cpasTable, cmapsData, arrangeIndex = 2) {
    const zeroData = Array.from({ length: cmapsData.length }, () => 0);
    let newCpasTable = cpasTable.data.map((element, index) => {
        const lastDta = element[element.length - 1];
        if (index !== 0) {
            element.splice(arrangeIndex, element.length, ...zeroData);
        }
        else {
            element.splice(arrangeIndex, element.length, ...cmapsData);
        }
        element.push(lastDta);
        return element;
    });
    return newCpasTable;
}
/**
 * 插入数据 UpdateCPASTableData
 * @params  resultData:请求后返回的data, cpasTableData:  CPAS基础数据data, arrangeIndex: 从第n+1列开始处理(默认从第n+1列开始处理)。
 * @returns newCpasTableData 返回处理之后的值
 *
 */
export function UpdateCPASTableData(resultData, cpasTableData, arrangeIndex = 2) {
    let newCpasTableData = cpasTableData.map((arr) => [...arr]);
    console.log("参数--- 数据", resultData, cpasTableData, newCpasTableData);
    // 将 resultData 数组中的值写入 newCpasTableData 数组中
    newCpasTableData = newCpasTableData.map((row, i) => {
        // 最后一行和第一行 不处理
        let name = row[0]?.replaceAll(" ", "") ?? "";
        if (i !== 0 && name) {
            console.log(name);
            let rowData = resultData.find((data) => data.itemName === name || data.ItemName === name);
            let newRow = rowData
                ? Object.values(rowData).slice(1)
                : row.slice(arrangeIndex, row.length - 1).fill(0);
            return [...row.slice(0, arrangeIndex), ...newRow, row[row.length - 1]];
        }
        return row;
    });
    console.log("返回---数据", newCpasTableData);
    return newCpasTableData;
}
// 去掉前后空格
export function trim(txt) {
    var afterTrimTxt = txt.replace(/^\s*/, "").replace(/\s*$/, "");
    return afterTrimTxt;
}
/**
 * 金额格式化
 */
export function formatNumberField(columns) {
    //金额格式化
    columns &&
        columns.forEach((field) => {
            if (field.FieldType == "number" && field.caption != "序号") {
                field.format = consts.JeFormat;
            }
        });
}
/**
 * 时间日期格式化
 * 2023-07-10T09:28:55.833Z   moment(2023-07-10T09:28:55.833Z).format(
        "YYYY-MM-DD HH:mm:ss"
      );

      const utcTime = moment.utc('2023-07-10T09:28:55.833Z');
const beijingTime = utcTime.tz('Asia/Shanghai').format('YYYY-MM-DD HH:mm:ss');
 */
export function formatDateField(listData) {
    listData.map((ele) => {
        if (ele && ele.编辑时间) {
            // ele.编辑时间 = moment(ele.编辑时间 + "08:00").format(
            //   "YYYY-MM-DD HH:mm:ss"
            // );
            const utcTime = moment.utc(ele.编辑时间);
            //edge调试时,没有 tz 方法,要使用原始的对象 by csb 20230712
            let beijingTime = utcTime.tz ? utcTime.tz("Asia/Shanghai") : utcTime;
            beijingTime = beijingTime.format("YYYY-MM-DD HH:mm:ss");
            ele.编辑时间 = beijingTime;
        }
        return ele;
    });
}
//判断是否打行运算标签
export function isOperatorTag(data) {
    if (!data || !data.length) {
        return false;
    }
    const lastData = data[data.length - 1];
    const rowStr = lastData[lastData.length - 1];
    const rowCfg = rowStr ? JSON.parse(rowStr) : {};
    console.log(rowCfg, "rowCfg111", lastData, rowCfg?.operator_r?.operatorTag);
    if (rowCfg?.operator_r?.operatorTag === "row") {
        return true;
    }
    return false;
}
/**
 * 把表格的列展开(多表头的列),平铺的字段,不包含children字段
 */
export function getExpandTableColumns(new_header, old_header, parentLabel) {
    old_header.forEach((oneHeader) => {
        if (oneHeader.children) {
            //有子项,把子项加入进来,支持多级表头的回写
            getExpandTableColumns(new_header, oneHeader.children, (parentLabel ? parentLabel + "|" : "") + oneHeader.label);
        }
        else {
            oneHeader.label =
                (parentLabel ? parentLabel + "|" : "") + oneHeader.label;
            new_header.push(oneHeader);
        }
    });
}
/**
 * 判断是否JSON
 * @param str 字符串
 * @returns boolean
 */
export function isJSONStr(str) {
    try {
        JSON.parse(str);
        return true;
    }
    catch (error) {
        return false;
    }
}
// 提取文件地址和文件名
export const extractFileInfo = (path) => {
    const parts = path.split(/[\\/]/); // 使用正则表达式分隔路径
    const fileName = parts.pop().split(".")[0]; // 弹出最后一个部分作为文件名
    const dirName = parts.join("/"); // 剩余部分拼接为文件地址
    return { dirName, fileName };
};
/**
 * 比较二维数组： 返回一个差异的新数组，重复的数据用null替代
 * @param arr1
 * @param arr2
 * @param header
 * @returns newArray
 */
export function compareArrays(arr1, arr2, headerData) {
    if (!arr1 && !arr2) {
        return [];
    }
    if (!arr1.length && !arr2.length) {
        return [];
    }
    if (!arr1 || !arr1.length) {
        return arr2;
    }
    if (!arr2 || !arr2.length) {
        return arr1;
    }
    // 创建结果数组，使用数组1的长度
    const result = new Array(arr1.length).fill(null);
    for (let i = 0; i < arr1.length; i++) {
        if (arr1[i].length) {
            result[i] = new Array(arr1[i].length).fill(null);
        }
    }
    // 遍历第一个数组
    for (let i = 0; i < arr1.length; i++) {
        // 如果第二个数组在相同位置有元素，且与第一个数组的元素不同，则替换
        const row = arr1[i];
        if (row && row.length) {
            for (let j = 0; j < row.length; j++) {
                let cell = row[j];
                let oldCell = arr2[i] && arr2[i].length ? arr2[i][j] : null;
                const type = headerData && headerData[j]?.config?.type
                    ? headerData[j]?.config?.type
                    : "";
                cell = typeof cell === "number" ? cell.toString() : cell;
                oldCell = typeof oldCell === "number" ? oldCell.toString() : oldCell;
                if ((cell || oldCell) && cell !== oldCell) {
                    result[i][j] = type !== "text" && !cell ? 0 : cell; //兼容后端处理：数字列为空的情况下传0
                    // result[i][j] = cell;
                }
                if (j === row.length - 1 || j === 0 || i === 0 || type === "text") {
                    result[i][j] = null;
                }
            }
        }
        else {
            // 如果相同位置的元素相同，或者第二个数组在该位置没有元素，则用null替换
            result[i] = null;
        }
    }
    return result;
}
